static void gtk_tree_view_set_property (GObject *object,
guint prop_id,
const GValue *value,
- GParamSpec *pspec,
- const gchar *trailer);
+ GParamSpec *pspec);
static void gtk_tree_view_get_property (GObject *object,
guint prop_id,
GValue *value,
- GParamSpec *pspec,
- const gchar *trailer);
-/* object signals */
+ GParamSpec *pspec);
+/* o signals */
static void gtk_tree_view_finalize (GObject *object);
+/* object signals */
+static void gtk_tree_view_destroy (GtkObject *object);
+
/* widget signals */
static void gtk_tree_view_setup_model (GtkTreeView *tree_view);
static void gtk_tree_view_realize (GtkWidget *widget);
o_class->set_property = gtk_tree_view_set_property;
o_class->get_property = gtk_tree_view_get_property;
+ object_class->destroy = gtk_tree_view_destroy;
+
widget_class->realize = gtk_tree_view_realize;
widget_class->unrealize = gtk_tree_view_unrealize;
widget_class->map = gtk_tree_view_map;
widget_class->drag_motion = gtk_tree_view_drag_motion;
widget_class->drag_drop = gtk_tree_view_drag_drop;
widget_class->drag_data_received = gtk_tree_view_drag_data_received;
-
+
container_class->forall = gtk_tree_view_forall;
container_class->remove = gtk_tree_view_remove;
container_class->focus = gtk_tree_view_focus;
_("The model for the tree view"),
GTK_TYPE_TREE_MODEL,
G_PARAM_READWRITE));
-
+
g_object_class_install_property (o_class,
PROP_HADJUSTMENT,
g_param_spec_object ("hadjustment",
tree_view->priv->pressed_button = -1;
tree_view->priv->press_start_x = -1;
tree_view->priv->press_start_y = -1;
-
+
gtk_tree_view_set_adjustments (tree_view, NULL, NULL);
_gtk_tree_view_update_size (tree_view);
}
if (tree_view->priv->drag_dest_row)
gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
-
+
+ if (tree_view->priv->anchor)
+ gtk_tree_row_reference_free (tree_view->priv->anchor);
+
+ if (tree_view->priv->cursor)
+ gtk_tree_row_reference_free (tree_view->priv->cursor);
+
g_free (tree_view->priv);
if (G_OBJECT_CLASS (parent_class)->finalize)
(* G_OBJECT_CLASS (parent_class)->finalize) (object);
}
+static void
+gtk_tree_view_destroy (GtkObject *object)
+{
+ GtkTreeView *tree_view = (GtkTreeView *) object;
+ GList *list;
+
+ gtk_tree_view_unref_tree (tree_view, tree_view->priv->tree);
+
+ for (list = tree_view->priv->columns; list; list = list->next)
+ g_object_unref (G_OBJECT (list->data));
+
+ _gtk_tree_selection_set_tree_view (tree_view->priv->selection, NULL);
+ g_object_unref (tree_view->priv->selection);
+}
+
/* Property handlers
*/
gtk_tree_view_set_property (GObject *object,
guint prop_id,
const GValue *value,
- GParamSpec *pspec,
- const gchar *trailer)
+ GParamSpec *pspec)
{
GtkTreeView *tree_view;
gtk_tree_view_get_property (GObject *object,
guint prop_id,
GValue *value,
- GParamSpec *pspec,
- const gchar *trailer)
+ GParamSpec *pspec)
{
GtkTreeView *tree_view;
tree_view = GTK_TREE_VIEW (object);
-
+
switch (prop_id)
{
case PROP_MODEL:
tree_view->priv->header_window = NULL;
gdk_cursor_destroy (tree_view->priv->cursor_drag);
- gdk_gc_destroy (tree_view->priv->xor_gc);
-
+ gdk_gc_destroy (tree_view->priv->xor_gc);
+
/* GtkWidget::unrealize destroys children and widget->window */
-
+
if (GTK_WIDGET_CLASS (parent_class)->unrealize)
(* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
}
GList *list;
g_return_if_fail (GTK_WIDGET_MAPPED (tree_view));
-
+
if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
{
GtkTreeViewColumn *column;
-
+
for (list = tree_view->priv->columns; list; list = list->next)
{
column = list->data;
gdk_window_show (tree_view->priv->bin_window);
gtk_tree_view_map_buttons (tree_view);
-
+
gdk_window_show (widget->window);
}
gtk_tree_view_size_request_buttons (GtkTreeView *tree_view)
{
GList *list;
-
+
tree_view->priv->header_height = 1;
if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_MODEL_SETUP))
{
GtkRequisition requisition;
GtkTreeViewColumn *column;
-
+
column = list->data;
-
+
gtk_widget_size_request (column->button, &requisition);
-
+
gtk_tree_view_column_set_width (column, MAX (column->width, requisition.width));
tree_view->priv->header_height = MAX (tree_view->priv->header_height, requisition.height);
}
GtkTreeViewColumn *column;
GtkAllocation allocation;
gint width = 0;
-
+
tree_view = GTK_TREE_VIEW (widget);
allocation.y = 0;
widget->allocation = *allocation;
tree_view = GTK_TREE_VIEW (widget);
-
+
gtk_tree_view_check_dirty (tree_view);
-
+
tmp_list = tree_view->priv->children;
while (tmp_list)
_gtk_tree_view_update_col_width (tree_view);
}
-
+
gtk_tree_view_size_allocate_buttons (widget);
tree_view->priv->hadjustment->page_size = allocation->width;
GtkRBTree *tree = NULL;
GtkRBNode *node = NULL;
gint bin_window_width = 0;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_TREE_VIEW (widget));
gdk_drawable_get_size (tree_view->priv->bin_window,
&bin_window_width, NULL);
-
+
/* FIXME need a style function appropriate for this */
gdk_draw_rectangle (tree_view->priv->bin_window,
widget->style->fg_gc[GTK_STATE_NORMAL],
gint x = 1, y = 1;
GdkDrawable *drawable;
gint bin_window_width;
-
+
widget = GTK_WIDGET (tree_view);
depth = gtk_tree_path_get_depth (path);
if (tree == NULL)
return NULL;
-
+
if (!gtk_tree_model_get_iter (tree_view->priv->model,
&iter,
path))
return NULL;
-
+
cell_offset = x;
background_area.y = y;
gdk_drawable_get_size (tree_view->priv->bin_window,
&bin_window_width, NULL);
-
+
drawable = gdk_pixmap_new (tree_view->priv->bin_window,
bin_window_width + 2,
background_area.height + 2,
0, 0,
bin_window_width + 1,
background_area.height + 1);
-
+
for (i = 0, list = tree_view->priv->columns; i < tree_view->priv->n_columns; i++, list = list->next)
{
GtkTreeViewColumn *column = list->data;
GdkRectangle cell_area;
-
+
if (!column->visible)
continue;
cell_area.y += TREE_VIEW_VERTICAL_SEPARATOR / 2;
cell_area.height -= TREE_VIEW_VERTICAL_SEPARATOR;
-
+
if (i == tree_view->priv->expander_column &&
TREE_VIEW_DRAW_EXPANDERS(tree_view))
{
&cell_area,
NULL,
0);
-
+
cell_offset += column->displayed_width;
}
if (tree_view->priv->tree == NULL)
return TRUE;
-
+
gtk_tree_view_check_dirty (GTK_TREE_VIEW (widget));
/* we want to account for a potential HEADER offset.
* That is, if the header exists, we want to offset our event by its
new_y = (event->area.y<TREE_VIEW_HEADER_HEIGHT (tree_view))?TREE_VIEW_HEADER_HEIGHT (tree_view):event->area.y;
/* y_offset is the */
-
+
y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree,
TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, new_y),
&tree,
cursor_path = NULL;
drag_dest_path = NULL;
-
+
if (tree_view->priv->cursor)
cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
else
*/
gboolean parity;
-
+
max_height = BACKGROUND_HEIGHT (node);
x_offset = -event->area.x;
cell_offset = 0;
highlight_x = 0; /* should match x coord of first cell */
-
+
background_area.y = y_offset + event->area.y;
background_area.height = max_height;
flags = 0;
flags |= GTK_CELL_RENDERER_PRELIT;
parity = _gtk_rbtree_node_find_parity (tree, node);
-
+
if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
flags |= GTK_CELL_RENDERER_SELECTED;
-
+
for (i = 0, list = tree_view->priv->columns; i < tree_view->priv->n_columns; i++, list = list->next)
{
GtkTreeViewColumn *column = list->data;
const gchar *detail = NULL;
-
+
if (!column->visible)
continue;
background_area.y,
background_area.width,
background_area.height);
-
+
if (i == tree_view->priv->expander_column &&
TREE_VIEW_DRAW_EXPANDERS(tree_view))
{
case GTK_TREE_VIEW_DROP_BEFORE:
highlight_y = background_area.y - TREE_VIEW_VERTICAL_SEPARATOR/2;
break;
-
+
case GTK_TREE_VIEW_DROP_AFTER:
highlight_y = background_area.y + background_area.height + TREE_VIEW_VERTICAL_SEPARATOR/2;
break;
-
+
case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
gtk_tree_view_draw_node_focus_rect (widget,
highlight_y);
}
}
-
+
y_offset += max_height;
if (node->children)
{
node = tree->root;
g_assert (node != tree->nil);
-
+
while (node->left != tree->nil)
node = node->left;
has_child = gtk_tree_model_iter_children (tree_view->priv->model,
}
}
while (y_offset < event->area.height);
-
+
if (cursor_path)
gtk_tree_path_free (cursor_path);
if (drag_dest_path)
gtk_tree_path_free (drag_dest_path);
-
+
return TRUE;
}
if (!GTK_WIDGET_REALIZED (tree_view))
return FALSE;
-
+
if ((node->flags & GTK_RBNODE_IS_PARENT) == 0)
return FALSE;
-
+
arrow.y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
-
+
arrow.height = BACKGROUND_HEIGHT (node);
gtk_tree_view_get_arrow_xrange (tree_view, &arrow.x, &x2);
return (x >= arrow.x &&
x < (arrow.x + arrow.height) &&
y >= arrow.y &&
- y < (arrow.y + arrow.height));
+ y < (arrow.y + arrow.height));
}
static void
{
if (tree_view->priv->prelight_node == NULL)
return;
-
+
GTK_RBNODE_UNSET_FLAG (tree_view->priv->prelight_node, GTK_RBNODE_IS_PRELIT);
-
+
if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT) &&
!coords_are_over_arrow (tree_view,
tree_view->priv->prelight_tree,
/* We need to unprelight the old arrow. */
{
GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_ARROW_PRELIT);
-
+
gtk_tree_view_draw_arrow (tree_view,
tree_view->priv->prelight_tree,
tree_view->priv->prelight_node,
x,
- y);
+ y);
}
-
+
tree_view->priv->prelight_node = NULL;
tree_view->priv->prelight_tree = NULL;
}
gint new_y;
GtkRBTree *old_prelight_tree;
GtkRBNode *old_prelight_node;
-
+
tree_view = (GtkTreeView *) widget;
-
+
if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE))
{
gint x;
old_prelight_tree = tree_view->priv->prelight_tree;
old_prelight_node = tree_view->priv->prelight_node;
-
- do_unprelight (tree_view, event->x, event->y);
-
+
+ do_unprelight (tree_view, event->x, event->y);
+
new_y = ((gint)event->y<TREE_VIEW_HEADER_HEIGHT (tree_view))?TREE_VIEW_HEADER_HEIGHT (tree_view):(gint)event->y;
_gtk_rbtree_find_offset (tree_view->priv->tree,
tree_view->priv->prelight_node,
NULL);
}
-
+
return TRUE;
}
TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, new_y),
&tree,
&node);
-
+
if (node == NULL)
return FALSE;
tree_view->priv->prelight_tree,
tree_view->priv->prelight_node,
NULL);
-
+
return TRUE;
}
tree_view->priv->prelight_tree,
tree_view->priv->prelight_node,
NULL);
-
+
ensure_unprelighted (tree_view);
return TRUE;
tree_view->priv->pressed_button = event->button;
tree_view->priv->press_start_x = event->x;
tree_view->priv->press_start_y = event->y;
- }
-
+ }
+
/* Handle the selection */
if (tree_view->priv->selection == NULL)
tree_view->priv->selection =
if (tree_view->priv->pressed_button == event->button)
tree_view->priv->pressed_button = -1;
-
+
if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE))
{
gpointer drag_data;
tree_view->priv->button_pressed_node->children->parent_tree = tree_view->priv->button_pressed_tree;
tree_view->priv->button_pressed_node->children->parent_node = tree_view->priv->button_pressed_node;
gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
-
+
if (gtk_tree_model_iter_children (tree_view->priv->model, &child, &iter))
gtk_tree_view_build_tree (tree_view,
tree_view->priv->button_pressed_node->children,
{
GtkTreeView *tree_view;
GtkTreePath *cursor_path;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_TREE_VIEW (widget));
cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
if (cursor_path == NULL)
return;
-
+
gtk_tree_view_draw_node_focus_rect (widget, cursor_path);
}
GtkRBTree *cursor_tree;
GtkRBNode *cursor_node;
GtkTreePath *cursor_path;
-
+
g_return_val_if_fail (container != NULL, FALSE);
g_return_val_if_fail (GTK_IS_TREE_VIEW (container), FALSE);
g_return_val_if_fail (GTK_WIDGET_VISIBLE (container), FALSE);
if (tree_view->priv->cursor)
cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
-
+
if (cursor_path == NULL)
{
GtkTreePath *tmp_path = gtk_tree_path_new_root ();
if (tree_view->priv->cursor)
gtk_tree_row_reference_free (tree_view->priv->cursor);
-
+
tree_view->priv->cursor =
gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, tmp_path);
cursor_path = tmp_path;
}
-
+
gtk_tree_selection_select_path (tree_view->priv->selection,
cursor_path);
- gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
+ gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
gtk_tree_path_free (cursor_path);
-
+
return TRUE;
}
}
cursor_path = NULL;
if (tree_view->priv->cursor)
cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
-
+
if (cursor_path == NULL)
{
GtkTreePath *tmp_path = gtk_tree_path_new_root ();
-
+
if (tree_view->priv->cursor)
gtk_tree_row_reference_free (tree_view->priv->cursor);
-
+
tree_view->priv->cursor =
gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, tmp_path);
cursor_path = tmp_path;
- }
+ }
gtk_tree_selection_select_path (tree_view->priv->selection,
cursor_path);
gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
- gtk_tree_path_free (cursor_path);
+ gtk_tree_path_free (cursor_path);
return TRUE;
}
/* Case 3. We have focus already, but no cursor. We pick the first one
* and run with it.
*/
-
+
if (cursor_path == NULL)
{
GtkTreePath *tmp_path = gtk_tree_path_new_root ();
-
+
if (tree_view->priv->cursor)
gtk_tree_row_reference_free (tree_view->priv->cursor);
-
+
tree_view->priv->cursor =
gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, tmp_path);
cursor_path = tmp_path;
-
+
gtk_tree_selection_select_path (tree_view->priv->selection,
cursor_path);
-
+
gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
-
- gtk_tree_path_free (cursor_path);
-
+
+ gtk_tree_path_free (cursor_path);
+
return TRUE;
}
gtk_widget_grab_focus (GTK_WIDGET (tree_view));
gtk_tree_path_free (cursor_path);
-
+
return TRUE;
}
if (direction == GTK_DIR_RIGHT)
gtk_widget_grab_focus (GTK_WIDGET (tree_view));
gtk_tree_path_free (cursor_path);
-
+
return TRUE;
}
/* undraw the old row */
gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
-
+
gtk_tree_path_free (cursor_path);
cursor_path = NULL;
gtk_tree_row_reference_free (tree_view->priv->cursor);
tree_view->priv->cursor = NULL;
}
-
+
switch (direction)
{
case GTK_DIR_TAB_BACKWARD:
if (event)
gdk_event_free (event);
-
+
cursor_path = _gtk_tree_view_find_path (tree_view,
cursor_tree,
cursor_node);
/* draw the newly-selected row */
gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
-
+
gtk_tree_path_free (cursor_path);
}
-
+
gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
gtk_widget_grab_focus (GTK_WIDGET (tree_view));
while (tmp_list)
{
GtkTreeViewColumn *column;
- column = tmp_list->data;
+ column = tmp_list->data;
if (column->button == widget)
{
gtk_widget_unparent (widget);
for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
{
- column = tmp_list->data;
-
+ column = tmp_list->data;
+
if (column->button)
(* callback) (column->button, callback_data);
}
if (tree == NULL)
goto done;
-
+
dirty_marked = gtk_tree_view_discover_dirty_iter (tree_view,
iter,
gtk_tree_path_get_depth (path),
}
else if (iter == NULL)
gtk_tree_model_get_iter (model, iter, path);
-
+
/* Update all row-references */
gtk_tree_row_reference_inserted (G_OBJECT (data), path);
if (tree == NULL)
goto done;
-
+
has_child = gtk_tree_model_iter_has_child (model, &real_iter);
/* Sanity check.
*/
GtkRBTree *tree;
GtkRBNode *node;
GList *list;
-
+
g_return_if_fail (path != NULL);
if (_gtk_tree_view_find_node (tree_view, path, &tree, &node))
* row was deleted. If it has, then anchor_path == NULL indicates the
* the anchor row was deleted.
*/
-
+
anchor_path = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
if (anchor_path == NULL ||
ensure_unprelighted (tree_view);
g_assert (tree_view->priv->prelight_node == NULL);
-
+
if ((tree->root->count == 1) &&
(tree_view->priv->tree != tree))
{
_gtk_rbtree_remove (tree);
}
else
- {
+ {
_gtk_rbtree_remove_node (tree, node);
}
-
+
_gtk_tree_view_update_size (GTK_TREE_VIEW (data));
}
gint i;
i = 0;
-
+
/* do stuff with node */
for (list = tree_view->priv->columns; list; list = list->next)
{
GList *list;
GtkTreeViewColumn *column;
GtkTreeIter iter;
-
+
if (!GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_MODEL_SETUP) &&
tree_view->priv->model)
gtk_tree_view_setup_model (tree_view);
-
+
for (list = tree_view->priv->columns; list; list = list->next)
{
column = list->data;
if (column->button)
w = MAX (w, column->button->requisition.width);
-
+
gtk_tree_view_column_set_width (column, w);
}
}
if (tree_view->priv->model == NULL)
return;
-
+
path = gtk_tree_path_new_root ();
if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, path))
{
gtk_tree_view_calc_size (tree_view, tree_view->priv->tree, &iter, 1);
_gtk_tree_view_update_size (tree_view);
}
-
+
gtk_tree_path_free (path);
-
+
for (list = tree_view->priv->columns; list; list = list->next)
{
column = list->data;
/* FIXME this has to be merged with update_button_contents() in
* gtktreeviewcolumn.c
*/
-
+
for (list = tree_view->priv->columns, i = 0; list; list = list->next, i++)
{
column = list->data;
-
+
if (column->button != NULL)
continue;
column->arrow = arrow;
column->alignment = alignment;
-
+
if (column->child)
label = column->child;
else
gtk_box_pack_end (GTK_BOX (hbox), arrow, FALSE, FALSE, 0);
else
gtk_box_pack_start (GTK_BOX (hbox), arrow, FALSE, FALSE, 0);
-
+
gtk_box_pack_start (GTK_BOX (hbox), alignment, TRUE, TRUE, 0);
-
+
gtk_container_add (GTK_CONTAINER (alignment), label);
gtk_container_add (GTK_CONTAINER (column->button), hbox);
}
gtk_tree_view_size_request_buttons (tree_view);
-
+
if (GTK_WIDGET_REALIZED (tree_view))
gtk_tree_view_realize_buttons (tree_view);
if (GTK_WIDGET_MAPPED (tree_view))
- gtk_tree_view_map_buttons (tree_view);
+ gtk_tree_view_map_buttons (tree_view);
}
#endif
if (!GTK_WIDGET_REALIZED (tree_view))
return;
-
+
rect.x = 0;
rect.width = tree_view->priv->width;
{
GtkRBTree *tree = NULL;
GtkRBNode *node = NULL;
-
+
_gtk_tree_view_find_node (tree_view, path, &tree, &node);
if (tree)
GtkStateType state;
GtkWidget *widget;
gint x_offset = 0;
-
+
if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
return;
widget = GTK_WIDGET (tree_view);
gtk_tree_view_get_arrow_xrange (tree_view, &x_offset, NULL);
-
+
area.x = x_offset;
area.y = CELL_FIRST_PIXEL (tree_view, tree, node);
area.width = tree_view->priv->tab_offset - 2;
_gtk_tree_view_update_col_width (tree_view);
}
-
+
gtk_widget_queue_resize (GTK_WIDGET (tree_view));
}
/**
* gtk_tree_view_new:
- *
+ *
* Creates a new #GtkTreeView widget.
- *
+ *
* Return value: A newly created #GtkTreeView widget.
**/
GtkWidget *
/**
* gtk_tree_view_new_with_model:
* @model: the model.
- *
+ *
* Creates a new #GtkTreeView widget with the model initialized to @model.
- *
+ *
* Return value: A newly created #GtkTreeView widget.
**/
GtkWidget *
/**
* gtk_tree_view_get_model:
* @tree_view: a #GtkTreeView
- *
+ *
* Returns the model the the #GtkTreeView is based on. Returns NULL if the
* model is unset.
- *
+ *
* Return value: A #GtkTreeModel, or NULL if none is currently being used.
**/
GtkTreeModel *
GtkTreeIter iter;
tree_view->priv->tree = _gtk_rbtree_new ();
-
+
g_signal_connectc (tree_view->priv->model,
"changed",
gtk_tree_view_changed,
gtk_tree_view_deleted,
tree_view,
FALSE);
-
+
if (tree_view->priv->columns == NULL)
return;
{
gtk_tree_view_build_tree (tree_view, tree_view->priv->tree, &iter, 1, FALSE, GTK_WIDGET_REALIZED (tree_view));
}
-
+
gtk_tree_path_free (path);
// gtk_tree_view_create_buttons (tree_view);
* gtk_tree_view_set_model:
* @tree_view: A #GtkTreeNode.
* @model: The model.
- *
+ *
* Sets the model for a #GtkTreeView. If the @tree_view already has a model
* set, it will remove it before setting the new model. If @model is NULL, then
* it will unset the old model.
if (tree_view->priv->drag_dest_row)
gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
-
+
GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_MODEL_SETUP);
}
/**
* gtk_tree_view_get_selection:
* @tree_view: A #GtkTreeView.
- *
+ *
* Gets the #GtkTreeSelection associated with @tree_view.
- *
+ *
* Return value: A #GtkTreeSelection object.
**/
GtkTreeSelection *
/**
* gtk_tree_view_get_hadjustment:
* @tree_view: A #GtkTreeView
- *
+ *
* Gets the #GtkAdjustment currently being used for the horizontal aspect.
- *
+ *
* Return value: A #GtkAdjustment object, or NULL if none is currently being
* used.
**/
if (tree_view->priv->hadjustment == NULL)
gtk_tree_view_set_hadjustment (tree_view, NULL);
-
+
return tree_view->priv->hadjustment;
}
* gtk_tree_view_set_hadjustment:
* @tree_view: A #GtkTreeView
* @adjustment: The #GtkAdjustment to set, or NULL
- *
+ *
* Sets the #GtkAdjustment for the current horizontal aspect.
**/
void
/**
* gtk_tree_view_get_vadjustment:
* @tree_view: A #GtkTreeView
- *
+ *
* Gets the #GtkAdjustment currently being used for the vertical aspect.
- *
+ *
* Return value: A #GtkAdjustment object, or NULL if none is currently being
* used.
**/
if (tree_view->priv->vadjustment == NULL)
gtk_tree_view_set_vadjustment (tree_view, NULL);
-
+
return tree_view->priv->vadjustment;
}
* gtk_tree_view_set_vadjustment:
* @tree_view: A #GtkTreeView
* @adjustment: The #GtkAdjustment to set, or NULL
- *
+ *
* Sets the #GtkAdjustment for the current vertical aspect.
**/
void
* @tree_view: A #GtkTreeView
* @hadj: The horizontal #GtkAdjustment to set, or NULL
* @vadj: The vertical #GtkAdjustment to set, or NULL
- *
+ *
* Sets the horizonal and or vertical #GtkAdjustment.
**/
static void
/**
* gtk_tree_view_get_headers_visible:
* @tree_view: A #GtkTreeView.
- *
+ *
* Returns TRUE if the headers on the @tree_view are visible.
- *
+ *
* Return value: Whether the headers are visible or not.
**/
gboolean
* gtk_tree_view_set_headers_visible:
* @tree_view: A #GtkTreeView.
* @headers_visible: TRUE if the headers are visible
- *
+ *
* Sets the the visibility state of the headers.
**/
void
g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
headers_visible = !! headers_visible;
-
+
if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE) == headers_visible)
return;
if (headers_visible)
{
gdk_window_move_resize (tree_view->priv->bin_window, x, y, tree_view->priv->width, tree_view->priv->height + TREE_VIEW_HEADER_HEIGHT (tree_view));
-
+
if (GTK_WIDGET_MAPPED (tree_view))
gtk_tree_view_map_buttons (tree_view);
}
/**
* gtk_tree_view_columns_autosize:
* @tree_view: A #GtkTreeView.
- *
+ *
* Resizes all columns to their optimal width.
**/
void
* gtk_tree_view_set_headers_clickable:
* @tree_view: A #GtkTreeView.
* @setting: TRUE if the columns are clickable.
- *
+ *
* Allow the column title buttons to be clicked.
**/
void
* gtk_tree_view_append_column:
* @tree_view: A #GtkTreeView.
* @column: The #GtkTreeViewColumn to add.
- *
+ *
* Appends @column to the list of columns.
- *
+ *
* Return value: The number of columns in @tree_view after appending.
**/
gint
* gtk_tree_view_remove_column:
* @tree_view: A #GtkTreeView.
* @column: The #GtkTreeViewColumn to remove.
- *
+ *
* Removes @column from @tree_view.
- *
+ *
* Return value: The number of columns in @tree_view after removing.
**/
gint
gtk_widget_queue_resize (GTK_WIDGET (tree_view));
}
-
+
return tree_view->priv->n_columns;
}
* @tree_view: A #GtkTreeView.
* @column: The #GtkTreeViewColumn to be inserted.
* @position: The position to insert @column in.
- *
+ *
* This inserts the @column into the @tree_view at @position. If @position is
* -1, then the column is inserted at the end.
- *
+ *
* Return value: The number of columns in @tree_view after insertion.
**/
gint
* @title: The title to set the header to.
* @cell: The #GtkCellRenderer.
* @Varargs: A NULL terminated list of attributes.
- *
+ *
* Creates a new #GtkTreeViewColumn and inserts it into the @tree_view at
* @position. If @position is -1, then the newly created column is inserted at
* the end. The column is initialized with the attributes given.
- *
+ *
* Return value: The number of columns in @tree_view after insertion.
**/
gint
va_start (args, cell);
attribute = va_arg (args, gchar *);
-
+
while (attribute != NULL)
{
column_id = va_arg (args, gint);
* gtk_tree_view_get_column:
* @tree_view: A #GtkTreeView.
* @n: The position of the column, counting from 0.
- *
+ *
* Gets the #GtkTreeViewColumn at the given position in the #tree_view.
- *
+ *
* Return value: The #GtkTreeViewColumn, or NULL if the position is outside the
* range of columns.
**/
if (n < 0 || n >= tree_view->priv->n_columns)
return NULL;
-
+
if (tree_view->priv->columns == NULL)
return NULL;
* @tree_view: a #GtkTreeView
* @tree_x: X coordinate of new top-left pixel of visible area
* @tree_y: Y coordinate of new top-left pixel of visible area
- *
+ *
* Scrolls the tree view such that the top-left corner of the visible
* area is @tree_x, @tree_y, where @tree_x and @tree_y are specified
* in tree window coordinates. The @tree_view must be realized before
vadj = tree_view->priv->vadjustment;
gtk_adjustment_set_value (hadj, CLAMP (tree_x, hadj->lower, hadj->upper));
- gtk_adjustment_set_value (vadj, CLAMP (tree_y, vadj->lower, vadj->upper));
+ gtk_adjustment_set_value (vadj, CLAMP (tree_y, vadj->lower, vadj->upper));
}
/**
* @column: The #GtkTreeViewColumn to move horizontally to.
* @row_align: The vertical alignment of the row specified by @path.
* @col_align: The horizontal alignment of the column specified by @column.
- *
+ *
* Moves the alignments of @tree_view to the position specified by
* @column and @path. If @column is NULL, then no horizontal
* scrolling occurs. Likewise, if @path is NULL no vertical scrolling
GdkRectangle cell_rect;
GdkRectangle vis_rect;
gint dest_x, dest_y;
-
+
/* FIXME work on unmapped/unrealized trees? maybe implement when
* we do incremental reflow for trees
*/
-
+
g_return_if_fail (tree_view != NULL);
g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
g_return_if_fail (row_align >= 0.0);
dest_x = vis_rect.x;
dest_y = vis_rect.y;
-
+
if (path)
{
dest_x = cell_rect.x +
* @column: A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
* @cell_x: A pointer where the X coordinate relative to the cell can be placed, or %NULL
* @cell_y: A pointer where the Y coordinate relative to the cell can be placed, or %NULL
- *
+ *
* Finds the path at the point (@x, @y) relative to @window. If
* @window is NULL, then the point is found relative to the widget
* coordinates. This function is expected to be called after an
* then it will be filled with the column at that point. @cell_x and
* @cell_y return the coordinates relative to the cell background
* (i.e. the background_area passed to gtk_cell_renderer_render()).
- *
+ *
* Return value: TRUE if a row exists at that coordinate.
**/
gboolean
GtkRBTree *tree;
GtkRBNode *node;
gint y_offset;
-
+
g_return_val_if_fail (tree_view != NULL, FALSE);
g_return_val_if_fail (tree_view->priv->tree != NULL, FALSE);
g_return_val_if_fail (tree_view->priv->bin_window != NULL, FALSE);
if (x < 0 || y < 0)
return FALSE;
-
+
if (column || cell_x)
{
GtkTreeViewColumn *tmp_column;
GList *list;
gint remaining_x = x;
gboolean found = FALSE;
-
+
for (list = tree_view->priv->columns; list; list = list->next)
{
tmp_column = list->data;
if (remaining_x <= tmp_column->width)
{
found = TRUE;
-
+
if (column)
*column = tmp_column;
if (cell_x)
*cell_x = remaining_x;
-
+
break;
}
remaining_x -= tmp_column->width;
TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y + tree_view->priv->vadjustment->value),
&tree, &node);
}
-
+
if (tree == NULL)
return FALSE;
if (cell_y)
*cell_y = y_offset;
-
+
if (path)
*path = _gtk_tree_view_find_path (tree_view, tree, node);
GtkTreeViewColumn *tmp_column = NULL;
gint total_width;
GList *list;
-
+
if (x1)
*x1 = 0;
for (list = tree_view->priv->columns; list; list = list->next)
{
tmp_column = list->data;
-
+
if (tmp_column == column)
break;
-
+
if (tmp_column->visible)
total_width += tmp_column->width;
}
-
+
if (tmp_column != column)
{
g_warning (G_STRLOC": passed-in column isn't in the tree");
return;
}
-
+
if (x1)
*x1 = total_width;
-
+
if (x2)
{
if (column->visible)
gint total_width;
GList *list;
gint i;
-
+
if (x1)
*x1 = 0;
for (list = tree_view->priv->columns; list; list = list->next)
{
tmp_column = list->data;
-
+
if (tmp_column == column)
break;
-
+
if (tmp_column->visible)
total_width += tmp_column->width;
++i;
}
-
+
if (tmp_column != column)
{
g_warning (G_STRLOC": passed-in column isn't in the tree");
if (i == tree_view->priv->expander_column)
total_width += tree_view->priv->tab_offset * _gtk_rbtree_get_depth (tree);
-
+
if (x1)
*x1 = total_width;
-
+
if (x2)
{
if (column->visible)
GtkTreeViewColumn *tmp_column = NULL;
gint total_width;
gint i;
-
+
i = 0;
total_width = 0;
for (list = tree_view->priv->columns; list; list = list->next)
x_offset = total_width;
break;
}
-
+
if (tmp_column->visible)
total_width += tmp_column->width;
if (x1)
*x1 = x_offset;
-
+
if (tmp_column && tmp_column->visible)
{
/* +1 because x2 isn't included in the range. */
* @path: a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
* @column: a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes
* @rect: rectangle to fill with cell rect
- *
+ *
* Fills the bounding rectangle in tree window coordinates for the
* cell at the row specified by @path and the column specified by
* @column. If @path is %NULL, the y and height fields of the
* not cover the entire tree; there are extra pixels in between rows,
* for example. The returned rectangle is equivalent to the @cell_area
* passed to gtk_cell_renderer_render().
- *
+ *
**/
void
gtk_tree_view_get_cell_area (GtkTreeView *tree_view,
{
GtkRBTree *tree = NULL;
GtkRBNode *node = NULL;
-
+
g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
g_return_if_fail (rect != NULL);
rect->y = 0;
rect->width = 0;
rect->height = 0;
-
+
if (path)
{
/* Get vertical coords */
-
+
_gtk_tree_view_find_node (tree_view, path, &tree, &node);
-
+
if (tree == NULL)
{
g_warning (G_STRLOC": no row corresponding to path");
if (column)
{
gint x2 = 0;
-
+
gtk_tree_view_get_cell_xrange (tree_view, tree, column, &rect->x, &x2);
rect->width = x2 - rect->x;
}
* @path: a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
* @column: a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes
* @rect: rectangle to fill with cell background rect
- *
+ *
* Fills the bounding rectangle in tree window coordinates for the
* cell at the row specified by @path and the column specified by
* @column. If @path is %NULL, the y and height fields of the
* buttons). Contrast with the cell_area, returned by
* gtk_tree_view_get_cell_area(), which returns only the cell itself,
* excluding surrounding borders and the tree expander area.
- *
+ *
**/
void
gtk_tree_view_get_background_area (GtkTreeView *tree_view,
{
GtkRBTree *tree = NULL;
GtkRBNode *node = NULL;
-
+
g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
g_return_if_fail (rect != NULL);
rect->y = 0;
rect->width = 0;
rect->height = 0;
-
+
if (path)
{
/* Get vertical coords */
-
+
_gtk_tree_view_find_node (tree_view, path, &tree, &node);
-
+
if (tree == NULL)
{
g_warning (G_STRLOC": no row corresponding to path");
if (column)
{
gint x2 = 0;
-
+
gtk_tree_view_get_background_xrange (tree_view, tree, column, &rect->x, &x2);
rect->width = x2 - rect->x;
}
/**
* gtk_tree_view_expand_all:
* @tree_view: A #GtkTreeView.
- *
+ *
* Recursively expands all nodes in the @tree_view.
**/
void
/* Ensure we don't have a dangling pointer to a dead node */
ensure_unprelighted (GTK_TREE_VIEW (data));
-
+
_gtk_rbtree_remove (node->children);
gtk_tree_path_free (path);
}
/**
* gtk_tree_view_collapse_all:
* @tree_view: A #GtkTreeView.
- *
+ *
* Recursively collapses all visible, expanded nodes in @tree_view.
**/
void
* @tree_view: a #GtkTreeView
* @path: path to a row
* @open_all: whether to recursively expand, or just expand immediate children
- *
+ *
* Opens the row so its children are visible
- *
+ *
* Return value: %TRUE if the row existed and had children
**/
gboolean
&tree,
&node))
return FALSE;
-
+
if (node->children)
return TRUE;
-
+
gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
if (! gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
return FALSE;
-
+
node->children = _gtk_rbtree_new ();
node->children->parent_tree = tree;
node->children->parent_node = node;
* gtk_tree_view_collapse_row:
* @tree_view: a #GtkTreeView
* @path: path to a row in the @tree_view
- *
+ *
* Collapses a row (hides its child rows).
- *
+ *
* Return value: %TRUE if the row was expanded
**/
gboolean
/* Ensure we don't have a dangling pointer to a dead node */
ensure_unprelighted (tree_view);
-
+
g_assert (tree_view->priv->prelight_node == NULL);
-
+
_gtk_rbtree_remove (node->children);
if (GTK_WIDGET_MAPPED (tree_view))
*
* Converts widget coordinates to coordinates for the
* tree window (the full scrollable area of the tree).
- *
+ *
**/
void
gtk_tree_view_widget_to_tree_coords (GtkTreeView *tree_view,
gint *ty)
{
g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
-
+
if (tx)
{
*tx = wx + tree_view->priv->hadjustment->value;
*
* Converts tree coordinates (coordinates in full scrollable
* area of the tree) to widget coordinates.
- *
+ *
**/
void
gtk_tree_view_tree_to_widget_coords (GtkTreeView *tree_view,
* gtk_tree_view_set_rules_hint
* @tree_view: a #GtkTreeView
* @setting: %TRUE if the tree requires reading across rows
- *
+ *
* This function tells GTK+ that the user interface for your
* application requires users to read across tree rows and associate
* cells with one another. By default, GTK+ will then render the tree
* hint to the theme engine that your tree makes alternating colors
* useful from a functional standpoint (since it has lots of columns,
* generally).
- *
+ *
**/
void
gtk_tree_view_set_rules_hint (GtkTreeView *tree_view,
gboolean setting)
{
g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
-
+
setting = setting != FALSE;
if (tree_view->priv->has_rules != setting)
/**
* gtk_tree_view_get_rules_hint
* @tree_view: a #GtkTreeView
- *
+ *
* Gets the setting set by gtk_tree_view_set_rules_hint().
- *
+ *
* Return value: %TRUE if rules are useful for the user of this tree
**/
gboolean
gtk_tree_view_get_rules_hint (GtkTreeView *tree_view)
{
g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
-
+
return tree_view->priv->has_rules;
}
GtkTargetList *dest_target_list;
GClosure *location_droppable_closure;
-
+
guint source_set : 1;
guint dest_set : 1;
};
if (di->row_draggable_closure)
g_closure_unref (di->row_draggable_closure);
-
+
di->source_target_list = NULL;
di->row_draggable_closure = NULL;
}
if (di->dest_target_list)
gtk_target_list_unref (di->dest_target_list);
-
+
di->location_droppable_closure = NULL;
di->dest_target_list = NULL;
}
if (di == NULL)
{
di = g_new0 (TreeViewDragInfo, 1);
-
+
g_object_set_data_full (G_OBJECT (tree_view),
"gtk-tree-view-drag-info",
di,
GtkTreePath *path = NULL;
GtkTreeViewColumn *column = NULL;
GdkRectangle visible_rect;
-
+
tree_view = GTK_TREE_VIEW (data);
gdk_window_get_pointer (tree_view->priv->bin_window,
- &x, &y, &state);
+ &x, &y, &state);
gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
&column,
NULL,
NULL);
-
+
if (path != NULL)
{
gtk_tree_view_scroll_to_cell (tree_view,
path,
column,
- 0.5, 0.5);
-
+ 0.5, 0.5);
+
gtk_tree_path_free (path);
}
}
-
+
return TRUE;
}
TreeViewDragInfo *di;
g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
-
+
di = ensure_info (tree_view);
clear_source_info (di);
gpointer user_data)
{
TreeViewDragInfo *di;
-
+
g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
gtk_drag_dest_set (GTK_WIDGET (tree_view),
NULL,
0,
actions);
-
+
di = ensure_info (tree_view);
- clear_dest_info (di);
+ clear_dest_info (di);
if (targets)
di->dest_target_list = gtk_target_list_new (targets, n_targets);
g_closure_ref (di->location_droppable_closure);
g_closure_sink (di->location_droppable_closure);
}
-
+
di->dest_set = TRUE;
}
gtk_tree_view_unset_rows_drag_source (GtkTreeView *tree_view)
{
TreeViewDragInfo *di;
-
+
g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
-
+
di = get_info (tree_view);
if (di)
gtk_tree_view_unset_rows_drag_dest (GtkTreeView *tree_view)
{
TreeViewDragInfo *di;
-
+
g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
-
+
di = get_info (tree_view);
if (di)
/* Note; this function is exported to allow a custom DND
* implementation, so it can't touch TreeViewDragInfo
*/
-
+
g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
current_dest = NULL;
-
+
if (tree_view->priv->drag_dest_row)
current_dest = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
tree_view->priv->drag_dest_pos = pos;
-
+
if (path)
{
tree_view->priv->drag_dest_row =
GtkTreeViewDropPosition *pos)
{
g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
-
+
if (path)
{
if (tree_view->priv->drag_dest_row)
GdkRectangle cell;
GtkTreeViewColumn *column = NULL;
GtkTreePath *tmp_path = NULL;
-
+
/* Note; this function is exported to allow a custom DND
* implementation, so it can't touch TreeViewDragInfo
*/
-
+
g_return_val_if_fail (tree_view != NULL, FALSE);
g_return_val_if_fail (tree_view->priv->tree != NULL, FALSE);
g_return_val_if_fail (drag_x >= 0, FALSE);
gtk_tree_view_widget_to_tree_coords (tree_view, drag_x, drag_y,
&x, &y);
-
+
/* If in the top quarter of a row, we drop before that row; if
* in the bottom quarter, drop after that row; if in the middle,
* and the row has children, drop into the row.
&column,
NULL,
&cell_y))
- return FALSE;
+ return FALSE;
gtk_tree_view_get_background_area (tree_view, tmp_path, column,
&cell);
offset_into_row = cell_y;
-
+
if (path)
*path = tmp_path;
else
gtk_tree_path_free (tmp_path);
tmp_path = NULL;
-
+
quarter = cell.height / 4.0;
-
+
if (pos)
{
if (offset_into_row < quarter)
{
- *pos = GTK_TREE_VIEW_DROP_BEFORE;
+ *pos = GTK_TREE_VIEW_DROP_BEFORE;
}
else if (offset_into_row < quarter * 2)
{
gint button;
gint cell_x, cell_y;
GtkTreeModel *model;
-
+
di = get_info (tree_view);
if (di == NULL)
if (tree_view->priv->pressed_button < 0)
return FALSE;
-
+
if (!gtk_drag_check_threshold (GTK_WIDGET (tree_view),
tree_view->priv->press_start_x,
tree_view->priv->press_start_y,
if (model == NULL)
return FALSE;
-
+
button = tree_view->priv->pressed_button;
tree_view->priv->pressed_button = -1;
if (path == NULL)
return FALSE;
-
+
/* FIXME if the path doesn't match the row_draggable predicate,
* return FALSE and free path
- */
+ */
/* FIXME Check whether we're a start button, if not return FALSE and
* free path
*/
-
+
context = gtk_drag_begin (GTK_WIDGET (tree_view),
di->source_target_list,
di->source_actions,
gdk_pixmap_unref (row_pix);
}
-
+
set_source_row (context, model, path);
gtk_tree_path_free (path);
-
+
return TRUE;
}
GtkTreeModel *model;
TreeViewDragInfo *di;
GtkTreePath *source_row;
-
+
tree_view = GTK_TREE_VIEW (widget);
model = gtk_tree_view_get_model (tree_view);
return;
di = get_info (GTK_TREE_VIEW (widget));
-
- if (di == NULL)
+
+ if (di == NULL)
return;
source_row = get_source_row (context);
if (source_row == NULL)
return;
-
+
/* We can implement the GTK_TREE_MODEL_ROW target generically for
* any model; for DragSource models there are some other targets
* we also support.
GtkTreeModel *model;
GtkTreeView *tree_view;
GtkTreePath *source_row;
-
+
tree_view = GTK_TREE_VIEW (widget);
model = gtk_tree_view_get_model (tree_view);
-
+
if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_SOURCE, "drag_data_delete"))
return;
-
+
di = get_info (tree_view);
if (di == NULL)
return;
source_row = get_source_row (context);
-
+
if (source_row == NULL)
return;
-
+
gtk_tree_drag_source_drag_data_delete (GTK_TREE_DRAG_SOURCE (model),
source_row);
gtk_tree_path_free (source_row);
-
+
set_source_row (context, NULL, NULL);
}
guint time)
{
TreeViewDragInfo *di;
-
+
di = get_info (GTK_TREE_VIEW (widget));
-
+
/* unset any highlight row */
gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
NULL,
GTK_TREE_VIEW_DROP_BEFORE);
-
+
remove_scroll_timeout (GTK_TREE_VIEW (widget));
remove_open_timeout (GTK_TREE_VIEW (widget));
}
gtk_tree_view_get_drag_dest_row (tree_view,
&dest_path,
&pos);
-
- if (dest_path &&
+
+ if (dest_path &&
(pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
{
tree_view->priv->open_dest_timeout = 0;
gtk_tree_path_free (dest_path);
-
+
return FALSE;
- }
+ }
else
{
if (dest_path)
TreeViewDragInfo *di;
GtkWidget *widget;
GtkTreePath *old_dest_path = NULL;
-
+
*suggested_action = 0;
*target = GDK_NONE;
-
+
widget = GTK_WIDGET (tree_view);
-
+
di = get_info (tree_view);
-
+
if (di == NULL)
{
/* someone unset us as a drag dest, note that if
remove_scroll_timeout (GTK_TREE_VIEW (widget));
remove_open_timeout (GTK_TREE_VIEW (widget));
-
+
return FALSE; /* no longer a drop site */
}
{
return FALSE;
}
-
+
if (!gtk_tree_view_get_dest_row_at_pos (tree_view,
x, y,
&path,
/* don't propagate to parent though */
return TRUE;
}
-
+
g_assert (path);
/* If we left the current row's "open" zone, unset the timeout for
gtk_tree_view_get_drag_dest_row (tree_view,
&old_dest_path,
&old_pos);
-
+
if (old_dest_path &&
(gtk_tree_path_compare (path, old_dest_path) != 0 ||
!(pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
if (old_dest_path)
gtk_tree_path_free (old_dest_path);
-
+
if (TRUE /* FIXME if the location droppable predicate */)
{
GtkWidget *source_widget;
-
+
*suggested_action = context->suggested_action;
-
+
source_widget = gtk_drag_get_source_widget (context);
-
+
if (source_widget == widget)
{
/* Default to MOVE, unless the user has
{
/* can't drop here */
remove_open_timeout (tree_view);
-
+
gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
NULL,
GTK_TREE_VIEW_DROP_BEFORE);
GtkTreeView *tree_view;
GdkDragAction suggested_action = 0;
GdkAtom target;
-
+
tree_view = GTK_TREE_VIEW (widget);
-
+
if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
return FALSE;
ensure_scroll_timeout (tree_view);
-
+
gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
if (path == NULL)
pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
{
tree_view->priv->open_dest_timeout =
- gtk_timeout_add (500, open_row_timeout, tree_view);
+ gtk_timeout_add (500, open_row_timeout, tree_view);
}
if (target == gdk_atom_intern ("GTK_TREE_MODEL_ROW", FALSE))
if (path == NULL)
return NULL;
-
+
if (pos == GTK_TREE_VIEW_DROP_BEFORE)
; /* do nothing */
else if (pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE ||
GdkAtom target = GDK_NONE;
TreeViewDragInfo *di;
GtkTreeModel *model;
-
+
tree_view = GTK_TREE_VIEW (widget);
model = gtk_tree_view_get_model (tree_view);
-
+
remove_scroll_timeout (GTK_TREE_VIEW (widget));
remove_open_timeout (GTK_TREE_VIEW (widget));
-
- di = get_info (tree_view);
-
+
+ di = get_info (tree_view);
+
if (di == NULL)
return FALSE;
-
+
if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_drop"))
return FALSE;
-
+
if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
return FALSE;
* treat drag data receives as a drop.
*/
set_status_pending (context, 0);
-
+
set_dest_row (context, model, path);
}
if (path)
gtk_tree_path_free (path);
-
+
/* Unset this thing */
gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
NULL,
GTK_TREE_VIEW_DROP_BEFORE);
-
+
if (target != GDK_NONE)
{
gtk_drag_get_data (widget, context, target, time);
GtkTreeView *tree_view;
GtkTreePath *dest_row;
GdkDragAction suggested_action;
-
+
tree_view = GTK_TREE_VIEW (widget);
model = gtk_tree_view_get_model (tree_view);
if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_data_received"))
- return;
-
+ return;
+
di = get_info (tree_view);
if (di == NULL)
{
GtkTreeModel *src_model = NULL;
GtkTreePath *src_path = NULL;
-
+
if (!gtk_selection_data_get_tree_row (selection_data,
&src_model,
&src_path))
gtk_tree_path_free (src_path);
}
}
-
+
gdk_drag_status (context, suggested_action, time);
if (path)
gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
NULL,
GTK_TREE_VIEW_DROP_BEFORE);
-
+
return;
}
-
+
dest_row = get_dest_row (context);
if (dest_row == NULL)
return;
-
+
if (selection_data->length >= 0)
{
if (gtk_tree_drag_dest_drag_data_received (GTK_TREE_DRAG_DEST (model),
selection_data))
accepted = TRUE;
}
-
- gtk_drag_finish (context,
+
+ gtk_drag_finish (context,
accepted,
(context->action == GDK_ACTION_MOVE),
time);
projects / gtk4.git / commitdiff